

package es.uab.es2.TimeTracker.nucli;






import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;


import org.apache.log4j.Logger;

/** 
 * Interacci� d'objectes per crear el arbre a partir d'un projecte arrel.
 * En aquest projecte arrel 
 *  es creen tasques i subprojectes.
 * Permet mitjan�ant un men� que es mostra per consola 
 * l'ececuci� de dos metodes per crear les estructures desitjades.
 * @author Jes�s Berm�dez , Ricard Figueras i Abel Rodr�guez
 * @version 30-mar�
 */

public final class Client {
   
    /**
     * {@link Projecte} principal utilitzada
     * per crear el arbre de Projectes .
     */
    private static Projecte p1;
    /**
     * {@link Tasca} filla del {@link Projecte} p1 utilitzada
     * per crear el arbre de Projectes.
     */
    private static Tasca t3;
    /**
     * Projecte fill del {@link Projecte} p1 utilitzada
     * per crear el arbre de Projectes.
     */
    private static Projecte p2;
    /**
     * {@link Tasca} filla del {@link Projecte} p2 utilitzada
     * per crear el arbre de Projectes.
     */
    private static Tasca t1;
    /**
     * {@link Tasca} filla del {@link Projecte} p2 utilitzada
     * per crear el arbre de Projectes.
     */
    private static Tasca t2;
    /**
     * Funcionalitat: evitar el problema del magin number 
     * al checkstyle al realitzar Sleep .
     */
    private static final long DOS_SEGONS = 2000;
    
    /**
     * Funcionalitat: evitar el problema del magin number 
     * al checkstyle al realitzar Sleep .
     */
    private static final long CUATRE_SEGONS = 4000;
    /**
     * Funcionalitat: evitar el problema del magin number 
     * al checkstyle al realitzar Sleep .
     */
    private static final long SET_SEGONS = 7000;
    /**
     * Funcionalitat: evitar el problema del magin number 
     * al checkstyle al realitzar Sleep .
     */
    private static final long DEU_SEGONS = 10000;
    /**
     * Funcionalitat: evitar el problema del magin number 
     * al checkstyle al realitzar Sleep .
     */
    private static final long TRES_SEGONS = 3000;
    
    

    /**
     * Projecte a partir del qual es comen�a el arbre a realitzar 
     * format per tasques i subprojectes.
     * @uml.property  name="arrel"
     * 
     */

  private static Projecte arrel = null;
  //new es.uab.es2.TimeTracker.nucli.Projecte();
   
  
  /**Creem constructor privat per evitar warning del Checkstyle.
   * 
   */
   private Client() {
	   
	   //onstructor privat per evitar warning del Checkstyle
   }
        
    /**
     * Visualitzar  la sortida per
     *  consola del contingut dels logger.debug  .
     * @uml.property  name="logger"
     */
        
    private static Logger logger = Logger.getLogger(Client.class);
    
       
    
    /**
     * Inicia de l'aplicacio on es crea l'arbre de projectes i tasques 
     * on es creen inst�ncies de les clases {@link Projecte} i {@link Tasca} ,
     *  i s'usen els seus m�todes.
     * L'arbre en q�esti� est� format per una arrel que cont� un projecte 
     * P1, el qual cont� una tasca T3 i un projecte P2. Aquest projecte 
     * P2 cont� dues tasques,
     * T1 i T2.
     * @param args 
     *                  Arguments per defecte de sistema.
     */
     public static void main(final String[] args) {
        // TODO Auto-generated method stub
         InputStreamReader isr = new InputStreamReader(System.in);
         BufferedReader br = new BufferedReader(isr);
         String str;
         try {
             int opcion = 0;
            logger.debug("MENU");
            logger.debug("1.Triar opcio per veure la fita 1 per a la nota C");
            logger.debug("2.Triar opcio per veure la fita 1 per a la nota B");
            logger.debug("Tria una opcio");
            str = br.readLine();
            opcion = Integer.parseInt(str);
          
                
                switch(opcion) {
                
                case 1://opcio 1
                    Client.opcioC();
                    break;
                case 2://opcio 2
                    Client.opcioB();
                    break;
                case 0://opcio 2
                    break;
                    default:
                        logger.debug("Opcio incorrecte");
                        break;
                }
           
          
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
         

    }

		/**
		 * Realitza un arbre de projectes 
		 * i tasques i executa la seg�ent seq��ncia:
		 * Comen�a a cronometrar la tasca T3 , s'espera 3 segons i para el 
		 * cronometre de la tasca T3.
		 * S'espera 7 segons i s'inicia el proc�s de cronometratge per la 
		 * tasca T2. S'espera 10 segons i s'atura el cronometratge de T2.
		 * Finalment es cronometre altre cop T3 durant 2 segons i 
		 * finalitza l'execuci�.
		 * 
		 */
			
public static void opcioC() {
    Rellotge clock = Rellotge.getInstancia();
    Taula t = new Taula();
    crearArbre();
    clock.addObserver(t);
   

try {
    System.out.println("Comen�a opcioC");
    clock.iniciar();
    t3.cronometrar("interval", "descripcio1", clock);
    Thread.sleep(TRES_SEGONS);
    t3.pararCronometre(clock);
    Thread.sleep(SET_SEGONS);
    t2.cronometrar("interval", "desccripcio1", clock);
    Thread.sleep(DEU_SEGONS);
    t2.pararCronometre(clock);
    t3.cronometrar("interval2", "descripcio2", clock);
    Thread.sleep(DOS_SEGONS);
    t3.pararCronometre(clock);
    clock.parar();
    Rellotge.setInstancia(null);
} catch (InterruptedException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
} 
	 }



/**
 * Realitza un arbre de projectes 
 * i tasques i executa la seg�ent seq��ncia:
 * Comen�a a cronometrar la tasca T3 i passats 4 segons comen�a a cronometrar 
 * la tasca T2. Passats 2 segons es para el cronometratge
 * de la tasca T3. Passats 2 segons es comen�a a cronometrar T1 i passats 4 
 * segons es para el cronometratge de T1. 
 * Passats 2 segons es para el cronometratge de la tasca T2 i finalment 
 * s'espera sense fer res 4 segons i es passa 
 * a cronometrar T3 durant 2 segons i es finalitza l'execuci�
 * 
 */		

public static void opcioB() {

    
    Rellotge clock = Rellotge.getInstancia();
    Taula t = new Taula();
    crearArbre();
    clock.addObserver(t);        
        try {
            System.out.println("Comen�a opcioB");
            clock.iniciar();
            t3.cronometrar("interval", "descripcio1", clock);
            Thread.sleep(CUATRE_SEGONS);
           
            t2.cronometrar("interval", "desc", clock);
            Thread.sleep(DOS_SEGONS);
          
            t3.pararCronometre(clock);
            Thread.sleep(DOS_SEGONS);
        
            t1.cronometrar("interval", "desc", clock);
            Thread.sleep(CUATRE_SEGONS);
            
            t1.pararCronometre(clock);
            Thread.sleep(DOS_SEGONS);
       
            t2.pararCronometre(clock);
            Thread.sleep(CUATRE_SEGONS);
            
            t3.cronometrar("interval", "interval tasca 3", clock);
            Thread.sleep(DOS_SEGONS);
            
            t3.pararCronometre(clock);
            clock.parar();
            Rellotge.setInstancia(null);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
		            e.printStackTrace();
		        } 
			 }

	
	/**
	 * Creem arbre de projectes i tasques a partir d'un projecte arrel.
	 * 
	 */
	public static void crearArbre() {
	    arrel = new es.uab.es2.TimeTracker.nucli.Projecte();
	   p1 = new Projecte("p1", "projecte principal", 
	            arrel, arrel.getActivitats());
	   t3 = new Tasca("t3", "tasca projecte principal", 
	            p1, p1.getActivitats());
	   p2 = new Projecte("p2", "subprojecte projecte principal", 
	            p1, p1.getActivitats());
	   t1 = new Tasca("t1", "tasca del projecte p2", 
	            p2, p2.getActivitats());
	   t2 = new Tasca("t2", "tasca del projecte p2", 
	           p2, p2.getActivitats());
	}

		
		/**
		 * Obtindr� la <tt>arrel</tt>.
		 * 
		 * @return  arrel  Retorna l'arrel.
		 */
		public static Projecte getArrel() {
			return arrel;
		}

			
			/**
			 * Obtindr� la <tt>p1</tt>.
			 * @return  p1  Retorna p1.
			 */
			public static Projecte getP1() {
				return p1;
			}

				
			/**
             * Obtindr� la <tt>p2</tt>.
             * @return  p2  Retorna p2.
             */
				public static Projecte getP2() {
					return p2;
				}


			
		

	
}
